//package cn.wuxing.mediation.common.utils;
//
//import cn.com.westone.wcspsdk.AuthSecretParameterSpec;
//import cn.com.westone.wcspsdk.CryptoServicePlatform;
//import cn.com.westone.wcspsdk.baseservice.co.COService;
//import cn.com.westone.wcspsdk.baseservice.co.Decryptor;
//import cn.com.westone.wcspsdk.baseservice.co.Encryptor;
//import cn.com.westone.wcspsdk.baseservice.co.KeyPair;
//import cn.com.westone.wcspsdk.baseservice.co.Mac;
//import cn.com.westone.wcspsdk.baseservice.co.ShortDataDecryptor;
//import cn.com.westone.wcspsdk.baseservice.co.ShortDataEncryptor;
//import cn.com.westone.wcspsdk.baseservice.km.KMKeyPair;
//import cn.com.westone.wcspsdk.baseservice.km.KMSecretKey;
//import cn.com.westone.wcspsdk.baseservice.km.KMService;
//import cn.com.westone.wcspsdk.baseservice.km.KeyNoUpdateStrategySpec;
//import cn.com.westone.wcspsdk.impl.base.WCSPCO;
//import cn.com.westone.wcspsdk.typicalservice.LightDataService;
//import cn.com.westone.wcspsdk.typicalservice.RecordSecurityService;
//import cn.com.westone.wcspsdk.typicalservice.SessionEncryptService;
//import cn.com.westone.wcspsdk.typicalservice.SessionEncryptService.SessionInitiator;
//import cn.com.westone.wcspsdk.typicalservice.SessionEncryptService.SessionResponder;
//import cn.com.westone.wcspsdk.util.ConversionUtils;
//import cn.com.westone.wcspsdk.util.SignatureUtils;
//
//import java.util.Arrays;
//import java.util.HashMap;
//
//public class SDKEncryptionUtils {
//
//    public static void main(String[] args) {
//        //密码服务平台URL，只能使用域名访问不能直接使用ip访问，如果不能使用DNS,则需要在本机hosts文件中配置域名ip映射
//        String url = "https://xxx:32443";
//        // tenantId: 租户ID，开通密码服务后通过密码服务平台获取
//        String tenantId = "xxx";
//        // appId: 应用ID，开通密码服务后通过密码服务平台获取
//        String appId = "xxxx";
//        // secret: 认证密码，开通密码服务后通过密码服务平台获取
//        String secret = "xxxxx";
//        // params: 密码服务平台初始化参数
//        HashMap<String, Object> params = new HashMap<>();
//        params.put(CryptoServicePlatform.INIT_PARAM_URL, url);
//        //SDK的工作目录需要读写权限，需要应用系统自己先创建完成 不同进程应该使用不同工作目录
//        params.put(CryptoServicePlatform.INIT_PARAM_WORKDIR, "workdir");
//        //软模块PIN码 使用本地计算服务时需要
//        String pin = "123456";
//        //SM4加解密
//        if (!dataEncryptSM4_KM_RemoteCO_1(tenantId, appId, params, secret)) System.exit(-1);
//        //长数据加解密(大于等于4096字节)
//        if (!longDataEncryptSM4_KM_RemoteCO_1(tenantId, appId, params, secret, pin)) System.exit(-1);
//        //签名验签
//        if (!dataSignSM2_RemoteCO_1(tenantId, appId, params, secret)) System.exit(-1);
//        //SM2加解密
//        if (!dataEncryptSM2_KM_RemoteCO_Short_1(tenantId, appId, params, secret)) System.exit(-1);
//        //MAC计算
//        if (!dataCBCMac_KM_RemoteCO_1(tenantId, appId, params, secret)) System.exit(-1);
//        //轻量级加解密
//        if (!dataLightEncrypt_1(tenantId, appId, params, secret)) System.exit(-1);
//        //会话加解密
//        if (!sessionEncrypt_1(tenantId, appId, params, secret)) System.exit(-1);
//        //记录数据安全MAC计算
//        if (!recordIntegrity_1(tenantId, appId, params, secret)) System.exit(-1);
//    }
//
//    private static boolean dataEncryptSM4_KM_RemoteCO_1(String tenantId, String appId, HashMap<String, Object> params, String secret) {
//        // tenantId: 租户ID，开通密码服务后通过密码服务平台获取
//        // appId: 应用ID，开通密码服务后通过密码服务平台获取
//        // params: 密码服务平台初始化参数
//        // secret: 认证密码，开通密码服务后通过密码服务平台获取
//
//        byte[] data = ConversionUtils.Data.fromUTF8String("待加密的示例数据");
//
//        try {
//            System.out.println("--------应用服务端 基础密码服务接口调用示例   SM4数据加解密 密钥管理服务 远程密码计算服务--------");
//
//            System.out.println("---密码服务平台初始化");
//            CryptoServicePlatform platform = CryptoServicePlatform.getInstance();
//            platform.init(tenantId, appId, params);
//
//            System.out.println("---密码服务平台认证，通过认证后应用服务端才能使用密钥管理服务和远程密码计算服务");
//            platform.authorize((new AuthSecretParameterSpec.Builder()).setSecret(secret).build());
//
//            System.out.println("---密钥管理服务初始化，该租户需开通密钥管理服务，并授权给应用使用");
//            KMService kmService = KMService.getInstance(platform);
//            kmService.init();
//
//            System.out.println("---在密钥管理服务中生成SM4对称加密密钥，从中获取并保存密钥标识字符串供以后使用");
//            String keyId = kmService.createSecretKey(KMService.ALGORITHM_SM4, KMService.KEY_USAGE_ENC,
//                    null, null, (new KeyNoUpdateStrategySpec.Builder()).build()).keyId();
//
//            System.out.println("---通过保存的密钥标识字符串从密钥管理服务中重新获取对称加密密钥");
//            KMSecretKey kmSecretKey = kmService.getSecretKey(keyId);
//
//            System.out.println("---远程密码计算服务初始化，该租户需开通远程密码计算服务，并授权给应用使用");
//            COService coService = COService.getInstance(COService.SERVICE_TYPE_CO_REMOTE, platform);
//            coService.init();
//
//            System.out.println("---产生SM4_CBC加解密所需的iv，该数据需与密钥标识字符串一起保存");
//            byte[] iv = coService.generateRandom(16);
//
//            byte[] encData = null;
//            System.out.println("---通过密码计算服务获取加密运算对象，用于SM4_CBC加密运算，算法填充为PKCS7");
//            try (Encryptor encryptor = coService.getEncryptor(kmSecretKey, iv,
//                    COService.ALGORITHM_MODE_CBC, COService.ALGORITHM_PADDING_PKCS7)) {
//                System.out.println("---通过加密运算对象对数据进行加密，配合update()可以实现对数据的分段加密");
//                encData = encryptor.doFinal(data);
//            }
//
//            byte[] decData = null;
//            System.out.println("---通过密码计算服务获取解密运算对象，用于SM4_CBC解密运算，密钥、iv、算法填充必须与加密相同");
//            try (Decryptor decryptor = coService.getDecryptor(kmSecretKey, iv,
//                    COService.ALGORITHM_MODE_CBC, COService.ALGORITHM_PADDING_PKCS7)) {
//                System.out.println("---通过解密运算对象对数据进行解密，配合update()可以实现对数据的分段解密");
//                decData = decryptor.doFinal(encData);
//            }
//
//            if (!Arrays.equals(data, decData)) {
//                throw new Exception("demo dataEncryptSM4_KM_RemoteCO_1 run failed!");
//            }
//            System.out.println("---示例数据加解密正确");
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//
//        System.out.println();
//        return true;
//    }
//
//    private static boolean longDataEncryptSM4_KM_RemoteCO_1(String tenantId, String appId, HashMap<String, Object> params, String s, String secret) {
//        // tenantId: 租户ID，开通密码服务后通过密码服务平台获取
//        // appId: 应用ID，开通密码服务后通过密码服务平台获取
//        // params: 密码服务平台初始化参数
//        // secret: 认证密码，开通密码服务后通过密码服务平台获取
//
//
//        try {
//            System.out.println("--------应用服务端 基础密码服务接口调用示例   SM4数据加解密 密钥管理服务 远程密码计算服务--------");
//
//            System.out.println("---密码服务平台初始化");
//            //注：CryptoServicePlatform对象不能多线程同时使用
//            CryptoServicePlatform platform = CryptoServicePlatform.getInstance();
//            platform.init(tenantId, appId, params);
//
//            System.out.println("---密码服务平台认证，通过认证后应用服务端才能使用密钥管理服务和远程密码计算服务");
//            platform.authorize((new AuthSecretParameterSpec.Builder()).setSecret(secret).build());
//
//            System.out.println("---密钥管理服务初始化，该租户需开通密钥管理服务，并授权给应用使用");
//            KMService kmService = KMService.getInstance(platform);
//            kmService.init();
//
//            System.out.println("---在密钥管理服务中生成SM4对称加密密钥，从中获取并保存密钥标识字符串供以后使用");
//            KMSecretKey kmSecretKey = kmService.createSecretKey(KMService.ALGORITHM_SM4, KMService.KEY_USAGE_ENC,
//                    null, null, (new KeyNoUpdateStrategySpec.Builder()).build());
//            System.out.println("---通过保存的密钥标识字符串从密钥管理服务中重新获取对称加密密钥");
////            KMSecretKey kmSecretKey = kmService.getSecretKey(keyId);
//
//            System.out.println("---远程密码计算服务初始化，该租户需开通远程密码计算服务，并授权给应用使用");
//            COService coService = COService.getInstance(COService.SERVICE_TYPE_CO_REMOTE, platform);
//            coService.init();
//            System.out.println("---产生SM4_CBC加解密所需的iv，该数据需与密钥标识字符串一起保存");
//            byte[] iv = coService.generateRandom(16);
//            System.out.println("---在密码计算服务中生成SM4_CBC对称加密密钥");
//            byte[] data = new byte[64 * 1023];
//            byte[] encData = new byte[0];
//            int length = data.length;
//            try (Encryptor encryptor = coService.getEncryptor(kmSecretKey, iv, COService.ALGORITHM_PADDING_PKCS7)) {
//                byte[] temp;
//                byte[] cipherTemp;
//                int offset = 0;
//                while (offset + WCSPCO.WCSP_CO_MAX_DATA_LENGTH <= length) {
//                    temp = Arrays.copyOfRange(data, offset, offset + WCSPCO.WCSP_CO_MAX_DATA_LENGTH);
//                    cipherTemp = encryptor.update(temp);
//                    int length1 = encData.length;
//                    encData = Arrays.copyOf(encData, length1 + cipherTemp.length);
//                    System.arraycopy(cipherTemp, 0, encData, length1, cipherTemp.length);
//                    offset += WCSPCO.WCSP_CO_MAX_DATA_LENGTH;
//                }
//                if (offset < length) {
//                    temp = Arrays.copyOfRange(data, offset, length);
//                    cipherTemp = encryptor.doFinal(temp);
//                } else {
//                    cipherTemp = encryptor.doFinal();
//                }
//                int oldlength = encData.length;
//                encData = Arrays.copyOf(encData, oldlength + cipherTemp.length);
//                System.arraycopy(cipherTemp, 0, encData, oldlength, cipherTemp.length);
//            }
//
//
//            byte[] decData = new byte[0];
//            int length2 = encData.length;
//            System.out.println("---通过密码计算服务获取解密运算对象，用于SM4_CBC解密运算，密钥、iv、算法填充必须与加密相同");
//            try (Decryptor decryptor = coService.getDecryptor(kmSecretKey, iv, COService.ALGORITHM_PADDING_PKCS7)) {
//                System.out.println("---通过解密运算对象对数据进行解密，配合update()可以实现对数据的分段解密");
//                byte[] temp;
//                byte[] plainTemp;
//                int offset = 0;
//                while (offset + WCSPCO.WCSP_CO_MAX_DATA_LENGTH <= length2) {
//                    temp = Arrays.copyOfRange(encData, offset, offset + WCSPCO.WCSP_CO_MAX_DATA_LENGTH);
//                    plainTemp = decryptor.update(temp);
//                    int length1 = decData.length;
//                    decData = Arrays.copyOf(decData, length1 + plainTemp.length);
//                    System.arraycopy(plainTemp, 0, decData, length1, plainTemp.length);
//                    offset += WCSPCO.WCSP_CO_MAX_DATA_LENGTH;
//                }
//                if (offset < length2) {
//                    temp = Arrays.copyOfRange(encData, offset, length2);
//                    plainTemp = decryptor.doFinal(temp);
//                } else {
//                    plainTemp = decryptor.doFinal();
//                }
//                int oldlength = decData.length;
//                decData = Arrays.copyOf(decData, oldlength + plainTemp.length);
//                System.arraycopy(plainTemp, 0, decData, oldlength, plainTemp.length);
//            }
//
//            if (!Arrays.equals(data, decData)) {
//                throw new Exception("demo dataEncryptSM4_KM_RemoteCO_1 run failed!");
//            }
//            System.out.println("---示例数据加解密正确");
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//
//        System.out.println();
//        return true;
//    }
//
//    private static boolean dataEncryptSM4_KM_LocalCO_Short_Batch_1(String tenantId, String appId, HashMap<String, Object> params, String secret, String pin) {
//        // tenantId: 租户ID，开通密码服务后通过密码服务平台获取
//        // appId: 应用ID，开通密码服务后通过密码服务平台获取
//        // params: 密码服务平台初始化参数
//        // secret: 认证密码，开通密码服务后通过密码服务平台获取
//        // pin: 密码计算服务用户PIN码
//
//        byte[][] datas = { ConversionUtils.Data.fromUTF8String("待加密的示例数据1"),
//                ConversionUtils.Data.fromUTF8String("待加密的示例数据2"),
//                ConversionUtils.Data.fromUTF8String("待加密的示例数据3") };
//
//        try {
//            System.out.println("--------应用服务端 基础密码服务接口调用示例   SM4数据加解密 密钥管理服务 本地密码计算服务 短数据 批量--------");
//
//            System.out.println("---密码服务平台初始化");
//            CryptoServicePlatform platform = CryptoServicePlatform.getInstance();
//            platform.init(tenantId, appId, params);
//
//            System.out.println("---密码服务平台认证，通过认证后应用服务端才能使用密钥管理服务");
//            platform.authorize((new AuthSecretParameterSpec.Builder()).setSecret(secret).build());
//
//            System.out.println("---密钥管理服务初始化，该租户需开通密钥管理服务，并授权给应用使用");
//            KMService kmService = KMService.getInstance(platform);
//            kmService.init();
//
//            System.out.println("---在密钥管理服务中生成SM4对称加密密钥，从中获取并保存密钥标识字符串供以后使用");
//            String keyId = kmService.createSecretKey(KMService.ALGORITHM_SM4, KMService.KEY_USAGE_ENC,
//                    null, null, (new KeyNoUpdateStrategySpec.Builder()).build()).keyId();
//
//            System.out.println("---通过保存的密钥标识字符串从密钥管理服务中重新获取对称加密密钥");
//            KMSecretKey kmSecretKey = kmService.getSecretKey(keyId);
//
//            System.out.println("---本地密码计算服务初始化");
//            COService coService = COService.getInstance(COService.SERVICE_TYPE_CO_LOCAL, platform);
//            coService.init();
//
//            System.out.println("---校验本地密码计算服务的用户PIN码");
//            coService.verifyPIN(pin);
//
//            byte[][] encDatas = null;
//            System.out.println("---通过密码计算服务获取短数据加密运算对象，用于SM4_ECB加密运算，算法填充为PKCS7");
//            try (ShortDataEncryptor encryptor = coService.getShortDataEncryptor(kmSecretKey, null,
//                    COService.ALGORITHM_MODE_ECB, COService.ALGORITHM_PADDING_PKCS7)) {
//                System.out.println("---通过短数据加密运算对象对海量短数据进行批量加密");
//                for (int i = 0; i < 6; ++i) {
//                    System.out.println("------对第" + (i + 1) + "批短数据进行批量加密");
//                    encDatas = encryptor.encrypt(datas);
//                }
//            }
//
//            byte[][] decDatas = null;
//            System.out.println("---通过密码计算服务获取短数据解密运算对象，用于SM4_ECB解密运算，密钥、iv、算法填充必须与加密相同");
//            try (ShortDataDecryptor decryptor = coService.getShortDataDecryptor(kmSecretKey, null,
//                    COService.ALGORITHM_MODE_ECB, COService.ALGORITHM_PADDING_PKCS7)) {
//                System.out.println("---通过短数据解密运算对象对海量数据进行批量解密");
//                for (int i = 0; i < 6; ++i) {
//                    System.out.println("------对第" + (i + 1) + "批短数据进行批量解密");
//                    decDatas = decryptor.decrypt(encDatas);
//                }
//            }
//
//            for (int i = 0; i < datas.length; ++i) {
//                if (!Arrays.equals(datas[i], decDatas[i])) {
//                    throw new Exception("demo dataEncryptSM4_KM_LocalCO_Short_Batch_1 run failed!");
//                }
//            }
//            System.out.println("---示例数据加解密正确");
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//
//        System.out.println();
//        return true;
//    }
//
//    private static boolean dataSignSM2_RemoteCO_1(String tenantId, String appId, HashMap<String, Object> params, String secret) {
//        // tenantId: 租户ID，开通密码服务后通过密码服务平台获取
//        // appId: 应用ID，开通密码服务后通过密码服务平台获取
//        // params: 密码服务平台初始化参数
//        // secret: 认证密码，开通密码服务后通过密码服务平台获取
//
//        byte[] data = ConversionUtils.Data.fromUTF8String("待签名的示例数据");
//
//        try {
//            System.out.println("--------应用服务端 基础密码服务接口调用示例   SM2数据签名验签 远程密码计算服务--------");
//
//            System.out.println("---密码服务平台初始化");
//            CryptoServicePlatform platform = CryptoServicePlatform.getInstance();
//            platform.init(tenantId, appId, params);
//
//            System.out.println("---密码服务平台认证，通过认证后应用服务端才能使用远程密码计算服务");
//            platform.authorize((new AuthSecretParameterSpec.Builder()).setSecret(secret).build());
//
//            System.out.println("---远程密码计算服务初始化，该租户需开通远程密码计算服务，并授权给应用使用");
//            COService coService = COService.getInstance(COService.SERVICE_TYPE_CO_REMOTE, platform);
//            coService.init();
//
//            System.out.println("---在密码计算服务中获取SM2非对称签名密钥对");
//            try (KeyPair keyPair = coService.getKeyPair(COService.ALGORITHM_SM2, COService.KEY_USAGE_SIGN)) {
//                System.out.println("---从密钥对中获取签名公钥数据并转换为Base64编码的字符串，给第三方用于验签");
//                String publicKeyData = ConversionUtils.Data.toBase64String(ConversionUtils.SM2PublicKeyData.fromGMT0016(keyPair.publicKey().getKeyData()));
//
//                System.out.println("---通过密码计算服务进行SM2签名");
//                byte[] signatureData = coService.signDigest(keyPair.privateKey(),
//                        SignatureUtils.sm2PreprocessSM3(ConversionUtils.Data.fromBase64String(publicKeyData), data));
//
//                System.out.println("---通过密码计算服务进行SM2验签");
//                if (!coService.verifyDigest(keyPair.publicKey(),
//                        SignatureUtils.sm2PreprocessSM3(ConversionUtils.Data.fromBase64String(publicKeyData), data), signatureData)) {
//                    throw new Exception("demo dataSignSM2_RemoteCO_1 run failed!");
//                }
//
//                System.out.println("---示例数据签名验签正确");
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//
//        System.out.println();
//        return true;
//    }
//
//    private static boolean dataEncryptSM2_KM_RemoteCO_Short_1(String tenantId, String appId, HashMap<String, Object> params, String secret) {
//        // tenantId: 租户ID，开通密码服务后通过密码服务平台获取
//        // appId: 应用ID，开通密码服务后通过密码服务平台获取
//        // params: 密码服务平台初始化参数
//        // secret: 认证密码，开通密码服务后通过密码服务平台获取
//
//        byte[] data = ConversionUtils.Data.fromUTF8String("待加密的示例数据");
//
//        try {
//            System.out.println("--------应用服务端 基础密码服务接口调用示例   SM2数据加解密 密钥管理服务 远程密码计算服务 短数据--------");
//
//            System.out.println("---密码服务平台初始化");
//            CryptoServicePlatform platform = CryptoServicePlatform.getInstance();
//            platform.init(tenantId, appId, params);
//
//            System.out.println("---密码服务平台认证，通过认证后应用服务端才能使用密钥管理服务和远程密码计算服务");
//            platform.authorize((new AuthSecretParameterSpec.Builder()).setSecret(secret).build());
//
//            System.out.println("---密钥管理服务初始化，该租户需开通密钥管理服务，并授权给应用使用");
//            KMService kmService = KMService.getInstance(platform);
//            kmService.init();
//
//            System.out.println("---在密钥管理服务中生成SM2非对称加密密钥对，从中获取并保存密钥标识字符串供以后使用");
//            String keyId = kmService.createKeyPair(KMService.ALGORITHM_SM2, KMService.KEY_USAGE_ENC,
//                    null, null, (new KeyNoUpdateStrategySpec.Builder()).build()).keyId();
//
//            System.out.println("---通过保存的密钥标识字符串从密钥管理服务中重新获取非对称加密密钥对");
//            KMKeyPair kmKeyPair = kmService.getKeyPair(keyId);
//
//            System.out.println("---远程密码计算服务初始化，该租户需开通远程密码计算服务，并授权给应用使用");
//            COService coService = COService.getInstance(COService.SERVICE_TYPE_CO_REMOTE, platform);
//            coService.init();
//
//            System.out.println("---通过密码计算服务进行短数据SM2加密");
//            byte[] encData = coService.encryptShortData(kmKeyPair.publicKey(), data);
//
//            System.out.println("---通过密码计算服务进行短数据SM2解密，解密私钥必须与加密公钥配对");
//            byte[] decData = coService.decryptShortData(kmKeyPair.privateKey(), encData);
//
//            if (!Arrays.equals(data, decData)) {
//                throw new Exception("demo dataEncryptSM2_KM_RemoteCO_Short_1 run failed!");
//            }
//            System.out.println("---示例数据加解密正确");
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//
//        System.out.println();
//        return true;
//    }
//
//    private static boolean dataCBCMac_KM_RemoteCO_1(String tenantId, String appId, HashMap<String, Object> params, String secret) {
//        // tenantId: 租户ID，开通密码服务后通过密码服务平台获取
//        // appId: 应用ID，开通密码服务后通过密码服务平台获取
//        // params: 密码服务平台初始化参数
//        // secret: 认证密码，开通密码服务后通过密码服务平台获取
//
//        byte[] data1 = ConversionUtils.Data.fromUTF8String("需要完整性保护的示例数据的第一部分");
//        byte[] data2 = ConversionUtils.Data.fromUTF8String("需要完整性保护的示例数据的第二部分");
//        byte[] data3 = ConversionUtils.Data.fromUTF8String("需要完整性保护的示例数据的第三部分");
//
//        try {
//            System.out.println("--------应用服务端 基础密码服务接口调用示例   CBCMac数据完整性保护和校验 密钥管理服务 远程密码计算服务--------");
//
//            System.out.println("---密码服务平台初始化");
//            CryptoServicePlatform platform = CryptoServicePlatform.getInstance();
//            platform.init(tenantId, appId, params);
//
//            System.out.println("---密码服务平台认证，通过认证后应用服务端才能使用密钥管理服务和远程密码计算服务");
//            platform.authorize((new AuthSecretParameterSpec.Builder()).setSecret(secret).build());
//
//            System.out.println("---密钥管理服务初始化，该租户需开通密钥管理服务，并授权给应用使用");
//            KMService kmService = KMService.getInstance(platform);
//            kmService.init();
//
//            System.out.println("---在密钥管理服务中生成CBCMac完整性保护密钥，从中获取并保存密钥标识字符串供以后使用");
//            String keyId = kmService.createSecretKey(KMService.ALGORITHM_SM4, KMService.KEY_USAGE_ENC,
//                    null, null, (new KeyNoUpdateStrategySpec.Builder()).build()).keyId();
//
//            System.out.println("---通过保存的密钥标识字符串从密钥管理服务中重新获取完整性保护密钥");
//            KMSecretKey kmSecretKey = kmService.getSecretKey(keyId);
//
//            System.out.println("---远程密码计算服务初始化，该租户需开通远程密码计算服务，并授权给应用使用");
//            COService coService = COService.getInstance(COService.SERVICE_TYPE_CO_REMOTE, platform);
//            coService.init();
//
//            System.out.println("---产生CBCMac完整性保护所需的iv，该数据需与密钥标识字符串一起保存");
//            byte[] iv = coService.generateRandom(16);
//
//            System.out.println("---初次计算数据的MAC值，并保存");
//            String cbcMac1 = null;
//            System.out.println("---通过密码计算服务获取CBCMac运算对象，用于CBCMac运算，算法填充为PKCS7");
//            try (Mac mac = coService.getCBCMac(kmSecretKey, iv, COService.ALGORITHM_PADDING_PKCS7)) {
//                System.out.println("---通过CBCMac运算对象对数据进行消息鉴别码运算，配合update()可以实现对数据的分段运算");
//                mac.update(data1);
//                mac.update(data2);
//                mac.update(data3);
//                cbcMac1 = ConversionUtils.Data.toBase64String(mac.doFinal());
//            }
//
//            System.out.println("---以后需要使用数据时再次计算数据MAC值，并与初次计算的MAC值对比");
//            String cbcMac2 = null;
//            System.out.println("---通过密码计算服务获取CBCMac运算对象，用于CBCMac运算，算法填充为PKCS7");
//            try (Mac mac = coService.getCBCMac(kmSecretKey, iv, COService.ALGORITHM_PADDING_PKCS7)) {
//                System.out.println("---通过CBCMac运算对象对数据进行消息鉴别码运算，配合update()可以实现对数据的分段运算");
//                mac.update(data1);
//                mac.update(data2);
//                mac.update(data3);
//                cbcMac2 = ConversionUtils.Data.toBase64String(mac.doFinal());
//            }
//
//            if (!cbcMac1.equals(cbcMac2)) {
//                throw new Exception("demo dataCBCMac_KM_RemoteCO_1 run failed!");
//            }
//            System.out.println("---示例数据CBCMac完整性校验正确");
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//
//        System.out.println();
//        return true;
//    }
//
//    private static boolean dataLightEncrypt_1(String tenantId, String appId, HashMap<String, Object> params, String secret) {
//        // tenantId: 租户ID，开通密码服务后通过密码服务平台获取
//        // appId: 应用ID，开通密码服务后通过密码服务平台获取
//        // params: 密码服务平台初始化参数
//        // secret: 认证密码，开通密码服务后通过密码服务平台获取
//
//        String data = "待加密的示例敏感数据";
//
//        try {
//            System.out.println("--------应用服务端 敏感数据轻量级加解密服务接口调用示例--------");
//
//            System.out.println("---该租户需开通密钥管理服务和远程密码计算服务，并授权给应用使用");
//
//            System.out.println("---获取敏感数据轻量级加解密服务实例");
//            LightDataService ldService = LightDataService.getInstance(tenantId, appId, params, secret);
//
//            System.out.println("---对示例敏感数据进行加密并将密文转换为Base64编码的字符串");
//            String encData = ConversionUtils.Data.toBase64String(ldService.encrypt(ConversionUtils.Data.fromUTF8String(data)));
//
//            System.out.println("---将加密后的敏感数据保存或传输");
//
//            System.out.println("---对Base64编码的密文字符串进解码和解密获得明文的示例敏感数据");
//            String decData = ConversionUtils.Data.toUTF8String(ldService.decrypt(ConversionUtils.Data.fromBase64String(encData)));
//
//            if (!data.equals(decData)) {
//                throw new Exception("demo dataLightEncrypt_1 run failed!");
//            }
//            System.out.println("---示例数据加解密正确");
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//
//        System.out.println();
//        return true;
//    }
//
//    private static boolean sessionEncrypt_1(String tenantId, String appId, HashMap<String, Object> params, String secret) {
//        // tenantId: 租户ID，开通密码服务后通过密码服务平台获取
//        // appId: 应用ID，开通密码服务后通过密码服务平台获取
//        // params: 密码服务平台初始化参数
//        // secret: 认证密码，开通密码服务后通过密码服务平台获取
//
//        String message = "待加密的示例敏感消息";
//
//        try {
//            System.out.println("--------应用服务端 会话消息加解密服务接口调用示例--------");
//
//            System.out.println("---该租户需开通远程密码计算服务，并授权给应用使用");
//
//            System.out.println("---获取会话消息加解密服务实例");
//            SessionEncryptService seService = SessionEncryptService.getInstance(tenantId, appId, params, secret);
//
//            System.out.println("---通过会话消息加解密服务获取会话发起方对象");
//            try (SessionInitiator initiator = seService.getSessionInitiator()) {
//                System.out.println("---获取会话发起方密钥协商数据并发送给会话响应方");
//                String initiatorKeyAgreementData = initiator.getKeyAgreementData();
//
//                System.out.println("---通过会话消息加解密服务获取会话响应方对象");
//                try (SessionResponder responder = seService.getSessionResponder(initiatorKeyAgreementData)) {
//                    System.out.println("---获取会话响应方密钥协商数据并发送给会话发起方");
//                    String responderKeyAgreementData = responder.getKeyAgreementData();
//
//                    System.out.println("---初始化会话发起方对象");
//                    initiator.init(responderKeyAgreementData);
//
//                    System.out.println("---会话发起方加密示例敏感消息并发送给会话响应方");
//                    String encMessage = initiator.encryptMessage(message);
//
//                    System.out.println("---会话响应方解密获得明文的示例敏感消息");
//                    String decMessage = responder.decryptMessage(encMessage);
//
//                    if (!message.equals(decMessage)) {
//                        throw new Exception("demo sessionEncrypt_1 run failed!");
//                    }
//                    System.out.println("---示例消息加解密正确");
//
//                    System.out.println("---会话响应方加密示例敏感消息并发送给会话发起方");
//                    encMessage = responder.encryptMessage(message);
//
//                    System.out.println("---会话发起方解密获得明文的示例敏感消息");
//                    decMessage = initiator.decryptMessage(encMessage);
//
//                    if (!message.equals(decMessage)) {
//                        throw new Exception("demo sessionEncrypt_1 run failed!");
//                    }
//                    System.out.println("---示例消息加解密正确");
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//
//        System.out.println();
//        return true;
//    }
//
//    private static boolean recordIntegrity_1(String tenantId, String appId, HashMap<String, Object> params, String secret) {
//        // tenantId: 租户ID，开通密码服务后通过密码服务平台获取
//        // appId: 应用ID，开通密码服务后通过密码服务平台获取
//        // params: 密码服务平台初始化参数
//        // secret: 认证密码，开通密码服务后通过密码服务平台获取
//
//        String field1 = "需要完整性保护记录的第一个字段";
//        String field2 = "需要完整性保护记录的第二个字段";
//        String field3 = "需要完整性保护记录的第三个字段";
//
//        try {
//            System.out.println("--------应用服务端 记录数据安全服务接口调用示例   记录完整性保护--------");
//
//            System.out.println("---该租户需开通密钥管理服务和远程密码计算服务，并授权给应用使用");
//
//            System.out.println("---获取敏感数据轻量级加解密服务实例");
//            RecordSecurityService rsService = RecordSecurityService.getInstance(tenantId, appId, params, secret);
//
//            System.out.println("---初次计算记录的MAC值，并与记录一起保存");
//            String mac = rsService.calculateMAC(field1, field2, field3);
//
//            System.out.println("---以后需要读取记录时再次计算记录的MAC值，并与初次计算的MAC值对比");
//            if (!rsService.verifyMAC(mac, field1, field2, field3)) {
//                throw new Exception("demo recordIntegrity_1 run failed!");
//            }
//            System.out.println("---示例数据完整性校验正确");
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//
//        System.out.println();
//        return true;
//    }
//
//}
